Week 1 — Types & Conditions

Built from 9 upstream notebooks @ fbd086a

From: 0_0_objectives.ipynb

vendor/virtual-pyprog/0_0_objectives.ipynb

מבוא לקורס פייתון

ברוכים הבאים לקורס פייתון ההיברידי של אוניברסיטת תל אביב! בסרטון זה תפגשו את צוות הקורס ותשמעו על מטרות הקורס, תכניו ואופן הלמידה שילווה אתכם לאורך הדרך:

TODO: הסרטון הזה יוחלף בסרטון הקדמה שלנו

מטרות הקורס

במהלך הקורס נכיר את שפת פייתון - אחת משפות התכנות הפופולריות והפשוטות ביותר, שתלווה אותנו בכל ההרצאות, התרגולים ותרגילי הבית. היא תהיה הכלי המרכזי שלנו ותיתן לכם בסיס מצוין להמשך הדרך בעולם התכנות. יחד עם זה, נתאמן גם על מיומנויות תכנות כלליות - כאלה שיעזרו לכם לא רק בפייתון אלא גם בכל שפה אחרת שתפגשו.

בנוסף, נתרגל חשיבה אלגוריתמית: איך לגשת לבעיה בצורה מסודרת ולמצוא לה פתרון יעיל. אלה כלים שילוו אתכם בכל תחום טכנולוגי שתמשיכו אליו.

חשוב להדגיש: הקורס מתמקד בצד הלוגי והאלגוריתמי של תכנות ושל מדעי המחשב, ואינו עוסק בפעולת החומרה של המחשב.

הקורס אינו מניח ידע מוקדם בתכנות, בפייתון או במדעי המחשב. עם זאת, הקצב מהיר, והקורס מגיע גם לתכנים מתקדמים.

המפתח להצלחה - תרגול מתמיד

מעבר לקריאת הרצאות והגעה לתרגולים - הכלי הכי חשוב להצלחה בחוץ הוא התנסות עצמאית בכתיבת קוד, ובפרט, השקעה בתרגילי הבית.

מוכנים? בואו נצא לדרך!

From: 0_1_hardware-to-software.ipynb

vendor/virtual-pyprog/0_1_hardware-to-software.ipynb

חומרה, תוכנה והשיטה הבינארית

אג’נדה

• חומרה, תכנה, שפת מכונה ושפת מחשב

• ייצוג מספרים בשפת מחשב

• מהו אלגוריתם?

• שפת התכנות פייתון

• פעולות בסיסיות בפייתון

בסרטון הבא נלמד (בקצרה) מה הקשר בין מחשב לבין תכנות.

מושגים חשובים שלמדנו:

במהלך הלימוד הכרנו כמה מושגים חשובים. חומרה היא הרכיבים הפיזיים של המחשב, כמו המעבד והזיכרון, שמאפשרים לו לפעול. על גבי רכיבים אלו פועלת התוכנה, שהיא אוסף התכניות ש”רצות” או “כתובות” על גבי החומרה. התוכנה מקודדת בשפת מכונה, כלומר כרצף של ביטים (bits) - יחידות מידע בינאריות שיכולות לקבל את הערך 0 או 1.

כדי לכתוב תוכנות, משתמשים בשפות תכנות, שהן שפות “מלאכותיות” שבעזרתן ניתן לנסח פקודות שהמחשב יודע לפרש ולבצע. במילים אחרות, שפות התכנות עוזרות לנו לגשר בין השפה הטבעית שלנו, לבין “שפת הביטים” באמצעותה מיוצג המידע המחשב.

מעניין לדעת!

בוויקיפדיה רשומות מעל 500 שפות תכנות שונות!

אז כיצד אותן שפות תכנות מצליחות לגשר בין השפה הטבעיות שלנו לבין שפת מכונה? נתחיל מהסבר כיצד מייצגים מספרים טבעיים באמצעות אפסים ואחדות.

ספירה בינארית

המחשב מבין אך ורק שפת מכונה, שמורכבת מרצפים של ביטים - כלומר אפסים ואחדות. כדי שנוכל לייצג באמצעותם מידע כמו מספרים, טקסט או תמונות, אנחנו זקוקים לשיטה מסודרת לקידוד. בסרטון הבא נתרכז בייצוג של מספרים שלמים בשפת מכונה.

שפות תכנות כגשר לשפת מכונה

מעבר לייצוג מספרים, ניתן גם לייצג בעזרת שפת מכונה את הפקודות שהמחשב מבצע. עם זאת, שפת מכונה אינה נוחה או אינטואיטיבית לשימוש עבור בני אדם, ולכן פותחו שפות תכנות שונות (כמו Python) כמו שמטרתן לגשר על הפער הזה. בני האדם כותבים את הקוד בשפת תכנות, וכדי להריץ אותו המחשב קודם “מתרגם” את הפקודות לשפת מכונה.

שימו לב: בקורס הזה לא נעסוק בפרטי תהליך התרגום, אלא נתמקד בכתיבה עצמה בשפת התכנות.

מעניין לדעת! שפות תכנות נבדלות זו מזו גם בדרך שבה הן מתורגמות למחשב.

• בשפות מסוג Interpreter - המחשב מתרגם כל שורת קוד בנפרד ומבצע אותה מיד.

• בשפות מסוג Compiler - קודם מתבצע תרגום של כל הקוד במלואו, ורק לאחר מכן המחשב מריץ את ההוראות שורה אחר שורה.

פייתון, שפת התכנות שנלמד בקורס זה, היא שפת Interpreter.

תכנית מחשב

עד כה דיברנו על ייצוג של מידע (מספרים) במחשב. אבל בדרך כלל נרצה לבצע חישוב כלשהו עם המידע הזה. כלומר, לכתוב הוראות (או פקודות) למחשב כדי לבצע פעולה כלשהי.

לרצף של הוראות הכתובות בשפת תכנות, שנועדו להשיג מטרה מסוימת נקרא תוכנית מחשב. ההוראות מבוצעות לפי סדר מוגדר: המחשב מריץ תחילה פקודה אחת, ורק לאחר שסיים אותה עובר לביצוע הפקודה הבאה בתור - בדיוק כמו שקוראים משפט אחר משפט בפסקה.

במהלך הקורס נקרא הרבה פעמים לתכנית מחשב בקיצור קוד.

מימוש פתרון בעיות (או אלגוריתמים) באמצעות תכנית מחשב

בעולם התכנות, אחד המושגים הבסיסיים ביותר הוא האלגוריתם – רצף סדור של צעדים שמגדירים כיצד לפתור בעיה מסוימת. האלגוריתם הוא תיאור מופשט של הפתרון, ללא תלות בשפת תכנות או בכלי עבודה מסוים. כדי שהאלגוריתם יהיה שימושי, הוא צריך להתייחס לקלט – הנתונים שהמשתמש או מערכת אחרת מספקים – ולפלט, שהוא התוצאה או הפתרון שמתקבל לאחר ביצוע הצעדים.

לדוגמא, אלגוריתם שמחשב את הממוצע יקבל כקלט רשימת מספרים ויחזיר כפלט את הערך הממוצע שלהם.

כאשר אנו נתקלים בבעיה חישובית, הכוונה היא לשאלה או משימה שניתן לנסח בצורה פורמלית ולפתור בעזרת מחשב. לאחר שניסחנו אלגוריתם לפתרון הבעיה, נותר לבצע מימוש בקוד – כלומר, לתרגם את הצעדים הלוגיים לשפה שמחשב מסוגל להריץ - כמו Python. המימוש מאפשר לקחת את הרעיון התאורטי ולהפוך אותו לתכנית שפועלת בפועל, מקבלת קלט, מבצעת את החישובים הנדרשים, ומחזירה את הפלט.

From: 0_2_python.ipynb

vendor/virtual-pyprog/0_2_python.ipynb

שפת התכנות פייתון (Python)

עד כה למדנו מהן שפות תכנות, ואיך המחשב מתרגם אותן לביטים כדי לבצע פעולות.
כעת נתחיל להכיר את שפת התכנות שנלמד בקורס - פייתון!

פייתון היא שפת תכנות שהושקה בשנת 1991, וכיום נחשבת לאחת מהנפוצות ביותר בעולם. היא מתאפיינת בפשטות ובקלות הלמידה שלה, מה שמאפשר זמן פיתוח קצר יחסית. פייתון מהירה מספיק עבור רוב היישומים ותומכת במגוון רחב של תחומים, כולל תחזוקת שרתים, פיתוח מערכות מורכבות, ולמידת מכונה (Machine Learning). בנוסף, היא נהנית מקהילה עצומה ושימוש נרחב בתעשייה, מה שהופך אותה לבחירה מועדפת על מתכנתים מתחילים ומנוסים כאחד.

מעניין לדעת!

השפה קרויה על שם נחש החנק, ומקור השם בהתייחסות לקבוצת הקומיקאים הבריטית - מונטי פייתון!

שימו לב: על מנת לשמור על אחידות, נשתמש במהלך הקורס אך ורק בגרסת פייתון 3.11 (Python 3.11.x)

סביבות עבודה

שיעורים ותרגולים

במהלך הקורס נשתמש בסביבת עבודה המוטמעת באתר זה, כך שלא תצטרכו להתקין שום דבר על המחשב האישי שלכם. הסביבה מאפשרת לכם להריץ קוד ישירות מתוך הדפדפן, לשנות אותו ולראות מיד את התוצאות. בדרך זו תוכלו לתרגל את מה שאתם לומדים בצורה אינטראקטיבית, לנסות רעיונות חדשים, ולבנות ביטחון ביכולות התכנות שלכם כבר מהשיעור הראשון. בנוסף, העבודה בענן מבטיחה שהכול יתבצע על אותה גרסה של פייתון וכלי העבודה, כך שלא יהיו בעיות של התאמות טכניות בין מחשבים שונים.

כדי לאפשר ריצה חיה של קוד, לחצו על כפתור הטיל שנמצא בראש המסך שלכם. כעת תוכלו להריץ שורות קוד על ידי כפתור הrun, ולערוך את תוכן הקוד על-ידי כתיבה בחלונית הקוד.

לפניכם שורת קוד. מה לדעתכם היא עושה? נסו להריץ אותה בעצמכם.

print("Hello World!")

כפי שבטח שמתם לב, השורה הדפיסה למסך את הטקסט “Hello world!”. זוהי מסורת ותיקה בעולם התכנות – כמעט כל מתכנת מתחיל את דרכו עם תכנית שמדפיסה את המשפט הזה.

ועכשיו גם אתם הצטרפתם למסורת והרצתם את תכנית המחשב הראשונה שלכם! מזל טוב!
זה רק הצעד הראשון – במהלך הקורס תריצו עוד הרבה תוכניות, וגם תכתבו בעצמכם המון קוד. ההרפתקה המלאה מתחילה עכשיו!

מטלות בית

כדי לפתור את המטלות שיינתנו במהלך הסמסטר ולהגישן, תצטרכו לעבוד גם עם סביבת עבודה מקומית המותקנת על המחשב שלכם.
הסביבה המקומית תחשוף אתכם להתנסות בסביבת תכנות כמו בעולם האמיתי. ותאפשר לכם שימוש בכלים מתקדמים יותר המשמשים מתכנתים בפועל – כמו כלי איתור שגיאות (debugging), עבודה עם קבצים ועוד.

הוראות התקנה ושימוש בסביבה זו יספק לכם לסגל הקורס שלכם.

לאחר שסיימתם להתקין את הסביבה המקומית שלכם, נסו להריץ את שורת הקוד print("Hello World!") וודאו כי היא רצה באופן תקין.

לסיום, ענו על השאלה הבאה:

התנסות ראשונה בפייתון

בסרטון זה נתחיל ללמוד פעולות בסיסיות שניתן לבצע בפייתון.

שימו לב

בסרטונים תראו פלטפורמה (מערכת לכתיבת קוד) שנקראת Codeboard. בקורס שלנו לא נשתמש בה, אך העקרונות והקוד שתראו זהים לחלוטין - תוכלו להריץ אותם בכל סביבת פייתון אחרת שבה נעבוד.

בסרטון זה למדנו על מספר פקודות ועקרונות חשובים בפייתון. ראשית, הכרנו את הפקודה print, שמאפשרת לנו כמתכנתים להציג ערכים ותוצאות על המסך. לאחר מכן פגשנו את האופרטורים, שהם פעולות חשבוניות בסיסיות שניתן לבצע בשפה. בנוסף, למדנו על הערות בקוד - טקסט שניתן להוסיף כדי להסביר מה הקוד עושה, ושאינו משפיע על הרצת התכנית, משום שהמחשב מתעלם ממנו בזמן הביצוע.

נסו זאת בעצמכם!

הנה הקוד שראינו בסרטון. ערכו את הקוד ונסו לענות את השאלות הבאות:

• מה יקרה אם נסמן שורה בסולמית?

• מה יקרה אם נשנה + ל-*?

• מה יקרה אם נוסיף עוד רווחים לפני או אחרי תווים מסוימים?

• באיזה סדר פייתון יבצע את הפעולה print(17-3  *  5)?

• האם פייתון יודע לעבוד עם מספרים שליליים?

print(13)
print(10)
print(1+2)
print        (7       -     4         )
print(3*8)
print(10/4)
print(2.3+1.7)
print(17 - 3*5)
print((17-3)*5)

13
10
3
3
24
2.5
4.0
2
70

עצרו וחשבו: מה יקרה אם נרצה לבצע print(3/0)? הרי למדתם בבית הספר שאי אפשר לחלק ב0.

בסרטון הבא תלמדו מה קורה כשמבקשים מהמחשב משהו שהוא לא יכול לעשות:

בחנו את עצמכם

חלונית הקוד שלפניכם מופיעה תוכנית בה חלק מהשורות גורמות לשגיאה. עליכם לתקן את כל השגיאות כך שהתוכנית תרוץ עד סופה (ובפרט, בסוף תודפס המילה “success”). ניתן לתקן את השגיאות בכל דרך שתרצו, אך אסור למחוק את כל השורה של פקודה שגורמת לשגיאה.

print( 1 + 2 - 3 * 4 / 5 ! 6)
print(12.3 * 8 + (12 - 4))
print(14 / (7 - (4 + 3)))
print( 2 + 4) * 6)
print ("<h3>success!</h3>")

  Cell In[11], line 4
    print( 2 + 4) * 6)
                     ^
SyntaxError: unmatched ')'

From: 0_3_variables-and-assignments.ipynb

vendor/virtual-pyprog/0_3_variables-and-assignments.ipynb

משתנים (variables) והשמות (assignment)

בסרטון למדנו על משתנים - מהם, למה צריך אותם, ואיך משתמשים בהם.

לכל משתנה יש:

• ערך – התוכן, כלומר הנתונים עצמם. (לדוגמה: 5.2)

• שם – כינוי המשמש אותנו כדי לגשת לערך (לדוגמה my_number).

ב-Python יוצרים משתנים ע”י השמת ערך לשם, באמצעות סימן ה=. לדוגמא, כדי לשים את 5.2 בתוך my_number נכתוב my_number=5.2

שימו לב! זה אינו סימן ה= של מתמטיקה. משמעות סימן ה= היא “תשמור את הערך מימין, בשם משמאל”.

בואו נעבור ונתרגל זאת:

ענו על השאלות הבאות:

1. עבור קטע הקוד הבא, קבעו (בלי להריץ) מהו ערכם של המשתנים x,y,z בתום ריצת הקוד

x = 12 
y = 7 
z = x - y 
x = z*2 + 3 
y = z - x + 16
print(x,y,z)

הריצו את הקוד כדי לבדוק את התשובה.

כדי לבדוק מה קורה בכל שלב בתכנית, הוסיפו עוד הדפסות (פקודת print).

תכנתו בעצמכם:

הגדירו שני משתנים בשם x ו-y. ערכו של x יהיה הגיל שלכם (בשנים), וערכו של y יהיה 3 הספרות האחרונות של מספר הטלפון שלכם (אם הספרה הראשונה מבין ה-3 היא 0 - התעלמו ממנה. למשל: אם 3 הספרות הן 012, אז y = 12).

הדפיסו – באמצעות הפקודה print - את סכום המשתנים (x+y), הפרש המשתנים (x-y), מכפלת המשתנים (x*y) ומנת המשתנים (x/y). בידקו שהתוצאות אכן נכונות על ידי חישוב ידני או שימוש במחשבון.

# Write your solution here

משתנים והשמות – כללים ופעולות נוספות

שמות משתנים

פייתון לא מאפשר לכל רצף אותיות להיות שם משתנה. שם משתנה חוקי בפייתון צריך לקיים את התנאים הבאים:

• מכיל רק אותיות באנגלית, מספרים ואת הסימן _.

• התו הראשון הוא לא מספר.

בנוסף, הכתיב המקובל עבור פייתון לשמות משתנים הוא באותיות קטנות, עם _ בין מילים. לדוגמה: my_variable.

השמה מחדש למשתנה קיים

ניתן לשנות ערך של משתנה על ידי השמה מחדש:

n=10
print(n)
n = 1.3141
print(n) 

10
1.3141

ניתן להשתמש במשתנים בתוך ביטויים

pi = 3.14159
print(pi * 2 + 1)

חובה לבצע השמה למשתנה טרם שימוש בו

אם ננסה להשתמש בשם משתנה שעדיין לא שמנו בו ערך, נקבל שגיאת ריצה.

check_this

קראו את קטע הקוד המופיע למטה וענו על השאלות הבאות:

a=4
print(a)
b=5
print(b)
c = a + b
c = c * 2
print(c)
print(b/a)

4
5
18
1.25

Python tutor

זה הזמן להכיר עוד כלי שנשתמש בו במהלך הקורס - Python tutor.

בעזרת Python tutor נוכל לעקוב אחרי שינוי המשתנים לאחר הרצת כל שורת קוד בתכנית שלנו.

התנסו בעצמכם

לפניכם מוצגת חלונית של Python Tutor ובה הקוד אותו ראינו בסרטון. הריצו את הקוד בצורה מבוקרת, כפי שראינו בסרטון. שימו לב איך המשתנים נוצרים ומשתנים בצד ימין של החלונית, וכיצד הפלט מופיע בחלונית הפלט. כשאתם מרגישים שהבנתם איך משתמשים ב-Python Tutor, אתם מוזמנים להמשיך לחלק הבא.

From: 1_0_intro_types.ipynb

vendor/virtual-pyprog/1_0_intro_types.ipynb

טיפוסים (type)

במהלך העבודה עם פייתון (או כל שפת תכנות אחרת) נרצה לייצג טיפוסים שונים של מידע, משום שכל סוג מידע מתאים לפעולות שונות. לדוגמה, על טקסט נרצה לבצע חיתוך או חיפוש מילים, בעוד שעל מספרים נרצה לבצע חישובים מתמטיים. אפילו בתוך עולם המספרים יש הבחנה: בין מספרים שלמים לבין מספרים עשרוניים.

אז למה צריך סוגי נתונים שונים?

לכל סוג נתונים יש יתרונות ושימושים שונים, ולכן חשוב שהמחשב יבחין ביניהם. ראשית, לכל טיפוס יש פעולות ייחודיות שמתאימות רק לו: על מספרים ניתן לבצע חיבור או כפל, אך לא הגיוני “לכפול” טקסטים אחד בשני. בנוסף, בחירה נכונה של טיפוס נתונים מאפשרת חיסכון בזיכרון - אם ידוע לנו שנצטרך רק את המספרים 0 ו־1, אין סיבה לייצג אותם באמצעות חמישה ביטים כמו שמייצגים מספרים גדולים יותר, ואפשר להסתפק בפחות. יתרון נוסף הוא מהירות הביצוע: מחשבים יודעים לבצע פעולות מהר יותר על טיפוסי נתונים קטנים ופשוטים, ולכן שימוש בטיפוס מתאים יכול לשפר את יעילות התוכנה.

באופן כללי במדעי המחשב, סוגי הנתונים השונים נקראים טיפוסי-נתונים (data-types) או מחלקות (classes). לכל טיפוס יש דרך מסויימת שבה הוא מיוצג בזיכרון של המחשב.

טיפוסים נפוצים

בשיעור זה נתמקד בטיפוסים הנפוצים הבאים:

1. מספריים: int ,float

2. טקסט/מחרוזת: str

3. לוגיים/בוליאניים: bool

במודולים הבאים נרחיב על כל טיפוס ואילו פעולות ניתן לעשות עליו.

From: 1_1_numerical_types.ipynb

vendor/virtual-pyprog/1_1_numerical_types.ipynb

טיפוסים מספריים: int וfloat

אג’נדה

• העמקה בטיפוסים int ו-float

• אופרטורים מספריים מתקדמים: מודולו (%) חילוק ללא שארית (//) וחזקה (**)

• משתנים והשמות

• פעולות השוואה

במודול הקודם פגשנו לראשונה את הדרך שבה פייתון מתמודדת עם מספרים. ראינו שהיא יודעת לעבוד גם עם מספרים שלמים וגם עם מספרים עשרוניים – כלומר מספרים שמכילים נקודה עשרונית, כמו 3.14 או 4.0 בנוסף, תרגלנו ביצוע של פעולות חשבון בסיסיות על סוגי המספרים הללו ולמדנו כיצד פייתון מטפלת בהם באופן טבעי כחלק מהשפה.

חשוב להבין שמבחינת פייתון, מספרים עם נקודה עשרונית ומספרים שלמים אינם אותו דבר – הם שייכים לטיפוסי נתונים שונים. מספרים שלמים, כמו 4, 0 או 56 המשתייכים למחלקה בשם int, שהיא קיצור של המילה integer באנגלית, שפירושה “מספר שלם”. לעומתם, מספרים הכוללים נקודה עשרונית, כמו 3.14, משתייכים למחלקה אחרת בשם float, קיצור של floating point. השם מתאר את צורת הייצוג של המספרים הללו במחשב – ייצוג שבו הנקודה העשרונית יכולה “לצוף” ולהופיע במיקומים שונים בהתאם לערך המספר.

נבחן דוגמא קונקרטיות: על מנת לייצג מספר עשרוני – למשל לייצג 0.1 – נשתמש בfloat. אך חשוב לדעת שמספרים כאלה סובלים מבעיית דיוק, כך שחישוב כמו 0.1+0.1+0.1 לא תמיד יניב את התוצאה המדויקת שציפינו לה (0.3), אלא תוצאה מקורבת (לדוגמא, 0.29999998 או 0.300000001). בקורס הזה לא נעמיק בסיבות לכך, אבל כן נדגיש שאם מספיק לנו לעבוד עם מספרים שלמים, כדאי להישאר עם טיפוס שמתאים לכך, כדי להימנע מהבעיות האלה, וכדי לחסוך בזכרון וזמן ריצה.

ההבחנה הזו בין שלמים לעשרוניים משמעותית מאוד, מפני שכל טיפוס נתונים מתנהג בצורה מעט שונה ותומך בפעולות שונות. בהמשך הקורס נראה כיצד ההבדלים הללו משפיעים על תכנות יומיומי ועל בחירת הטיפוס המתאים לכל משימה.

החזרת הטיפוס של משתנה

על מנת לבדוק מהו הטיפוס של הערך הנמצא במשתנה, נשתמש בפקודה type, המחזירה את מחזירה את סוג המשתנה (או הביטוי):

n=10
print(n, type(n)) 
n = 1.3141
print(n, type(n)) 

10 <class 'int'>
1.3141 <class 'float'>

ניתן לבצע זאת על כל משתנה בכל שלב בקורס, כך שאם אינכם בטוחים בטיפוס של משתנה מסוים, תמיד ניתן לבדוק זאת.

שילוב int ל-float באותו אופרטור

כיוון שגם מספרים שלמים (int) וגם מספרים עשרוניים (float) הם סוגי נתונים מספריים, פייתון יודעת לשלב ביניהם בצורה טבעית בתוך אותו ביטוי. כאשר מופיעים יחד ערכים משני הטיפוסים, פייתון מבצעת המרה אוטומטית כך שהתוצאה תהיה מטיפוס float. הסיבה לכך היא שטיפוס float גמיש יותר ומסוגל לייצג גם מספרים עם נקודה עשרונית וגם מספרים שלמים. למשל, בביטוי 1 + 2.5 מתקבל הערך 3.5, שהוא מספר מטיפוס float.

חשוב לשים לב ש-float עשוי להופיע גם במקרים שבהם הביטוי מכיל אך ורק מספרים שלמים. לדוגמה, אם נחשב 10/4, נקבל את התוצאה ‎2.5‎ – מספר עשרוני מטיפוס float. אפילו במקרה של חלוקה “מדויקת”, כמו 10/2, נקבל את ‎5.0‎, שהוא גם כן float. המשמעות היא שכל פעולת חילוק בפייתון, ללא קשר לערכים המעורבים, מחזירה תוצאה מטיפוס float. בהמשך נלמד גם על אופרטורים נוספים שיכולים להחזיר תוצאה שלמה, במידה ונרצה בכך.

אופרטורים מספריים נוספים

עד כה ראינו את האופרטורים החשבוניים חיבור (+), חיסור (-), כפל (*), וחילוק (/). כעת נלמד עוד שלושה אופרטורים חשובים:

חילוק ללא שארית - //

נותן רק את החלק השלם של תוצאת החלוקה. כלומר את מנת החלוקה, מעוגלת למטה. למשל, כאשר מחלקים 10/4, התוצאה היא 2.5. החלק השלם של התוצאה הוא 2, או במילים אחרות 4 נכנס ב-10 פעמיים שלמות (ונשארת עוד שארית של 2). כאשר מחשבים 4//10 מקבלים רק את המנה, כלומר 2.

להלן מספר דוגמאות שדרכן נבין את ההבדל בין / ל//. הוסיפו פקודות דומות אם אתם מעוניינים לראות עוד דוגמאות:

# Division examples
print(10/4, 10//4)
print(10/3, 10//3)
print(3/4, 3//4)

2.5 2
3.3333333333333335 3
0.75 0

modulo - %

נותן את שארית החלוקה. כלומר מה שנשאר אחרי החלוקה השלמה. לדוגמא, כשמבצעים 3//11 מקבלים 9, ונשאר 2 שלא הצלחנו לחלק.

דוגמאות נוספות:

print(11%3)
print(10%4)
print(3%4)

2
2
3

חזקה - **

פעולת החזקה המוכרת מסומנת על ידי **. לדוגמא, כשמבצעים 3**2 נחשב בעצם 2 בחזקת 3 ונקבל 8.

דוגמאות נוספות:

print(4**3)
print(3**0)

64
1

בחנו את עצמכם

עבור כל אחד מהביטויים הבאים, ענו האם הוא מטיפוס int או float:

סיכום פעולות אריתמטיות

אופרטור	שימוש	תיאור
+	x + y	סכום של x ו־y
-	x - y	חיסור y מ־x
*	x * y	כפל של x ב־y
**	x ** y	חזקה של x בחזקת y
/	x / y	חילוק של x ב־y
//	x // y	חילוק שלם של x ב־y: מחזיר את החלק השלם (מעוגל למטה) של תוצאת החילוק
%	x % y	מודולו: השארית של החילוק של x ב־y

השוואות בין מספרים

TODO: אמיר מזכיר בסרטון הזה את השידוך היציב - לחתוך

בסרטון זה למדנו את הדרכים להשוות בין מספרים בפייתון:

• בדיקה אם מספר קטן ממש או גדול ממש ממספר אחר<, >

• בדיקה אם מספר קטן (או גדול) ממספר אחר או שווה לו =>.

• בדיקה אם שני מספרים הם שווים == - ושמנו לב להבדל מפעולת ההשמה בפקודה =

• בדיקה אם שני מספרים שונים אחד מהשני =!

בדיקות אלו מחזירות ערכים של True או של False - האם המשפט שהצגנו נכון או לא. הערכים הללו הם מטיפוס bool, עליו נרחיב בהמשך.

לנוחיותכם חלונית עם הקוד שראינו בסרטון. מוזמנים להריץ בעצמכם.

#print(3 < 4)
#print(3 > 4)
x = 3
y = 4
# print(x*2 < y  + 1)
# print(x==y)
# print(x+1 == y)
# x = y
# print(x)
# print(y)a
# print(3 != 4)
# print(3 <= 4)
# print(3 <= 3)
# print(3 >= 4)
print(3 >= 3)

True

בחנו את עצמכם

לפניכם קטע קוד ובו 3 משתנים - x,y,z. המשתנים מאותחלים ל-0. לאחר אתחול המשתנים, ישנן מספר הדפסות של פעולות השוואה הכוללות את המשתנים הנ”ל. עליכם לשנות את ערכם של x,y,z עד שכל ההדפסות מדפיסות True.

רמז:

יש לפחות משתנה אחד שעבורו יש מספר ערכים שיובילו לפתרון נכון, ויש לפחות משתנה אחד שעבורו יש רק ערך אחד אפשרי.

נסו להבין מיהו המשתנה שעבורו רק ערך אחד אפשרי, והמשיכו משם. בנוסף, הפתרון עשוי לכלול ערכים שאינם שלמים.

x = 0
y = 0
z = 0


print(x + y < z)
print(3*x == 2*y)
print(z < 20)
print(x + 1 == 6)
print(y / 3 >= 2)

פייתון יודע להשוות בין מספר מסוג int למספר מסוג float:

print(5==5.0)
print(5 < 5.7)

True

כפי שציינו קודם, כאשר מבצעים השוואה בפייתון, התוצאה היא ערך מטיפוס בוליאני (bool) – כלומר True או False. זהו טיפוס נתונים בפני עצמו, בדיוק כמו מספרים (int,float). ניתן לשמור ערכים בוליאניים במשתנים:

x=3<3
print(x, type(x))

False <class 'bool'>

במודול הבא, נראה פעולות נוספות שניתן לבצע באמצעות הטיפוס bool.

סיכום אופרטורי השוואה

משווים בין משתנים ומחזירים ערך בוליאני (True / False)

אופרטור	שם	תיאור
x < y	קטן מ־	אמת אם x קטן מ־y, אחרת שקר.
x > y	גדול מ־	אמת אם x גדול מ־y, אחרת שקר.
x <= y	קטן או שווה ל־	אמת אם x קטן או שווה ל־y, אחרת שקר.
x >= y	גדול או שווה ל־	אמת אם x גדול או שווה ל־y, אחרת שקר.
x == y	שווה	אמת אם x שווה ל־y, אחרת שקר.
x != y	שונה	אמת אם x שונה מ־y, אחרת שקר.

From: 1_2_booleans.ipynb

vendor/virtual-pyprog/1_2_booleans.ipynb

טיפוס בוליאני: bool

אג’נדה

• הסבר על הטיפוס bool

• אופרטורים בוליאניים - and ,or ו-not

טיפוס בוליאני מייצג אמת ושקר, כלומר קיימים רק 2 ערכים אפשריים בלבד לטיפוס זה: True ו-False.

שימו לב

• True ו-False הן מילים שמורות, כלומר, לא ניתן להשתמש בהם לצרכים אחרים כמו הגדרת משתנים

• True ו-False תמיד יופיעו עם אות גדולה בהתחלה ואותיות קטנות בהמשך

• True ו-False הן תוצאות אופרטורי השוואה כמו <, > == וכו’

טיפוס זה חשוב במיוחד בבדיקות שונות שנעשה על הנתונים שלנו. כפי שראינו, התוצאות של פעולות השוואה מחזירות ערכים בוליאניים, ואותם נוכל לשלב בהמשך גם משפטי תכנות מורכבים יותר שנראה בהמשך - לולאות ותנאים.

אופרטורים בוליאניים

אופרטורים בוליאניים פועלים על ערכים בוליאניים ומחזירים ערך בוליאני

קיימים שלושה אופרטורים לוגיים: and or ו-not

האופרטור and

תחביר: a and b
פעולה זו מחזירה True רק אם שני הערכים (a וגם b) הם True. בכל מקרה אחר (כלומר אם אחד מהם או שניהם הם False) התוצאה תהיה False.

כדי להבין זאת טוב יותר, נסתכל על טבלת האמת של האופרטור and.
טבלת אמת מציגה את התוצאה של הפעולה עבור כל צירוף אפשרי של ערכים בוליאניים של a ו־b:

a	b	a and b
True	True	True
True	False	False
False	True	False
False	False	False

נסו בעצמכם

a=True
b=True
print(a and b)

a=2>1
b=2<1
print(a and b)


print(False and False)

True
False
False

שאלת חשיבה: אם נתון שa=False, ולא ידוע הערך של b, מה יהיה הערך של a and b?

האופרטור or

תחביר: a or b מחזיר True אם לפחות אחד מהמשתנים a או b הם True. אחרת, מחזיר False.
הor בתכנות שונה קצת מהמילה “או” בשפה הרגילה - בפייתון, אם שואלים אתכם אם “תרצו גלידה או ארטיק?” אתם יכולים לענות פשוט “כן”.

שימו לב להבדל בין טבלאות האמת של and ושל or.
באלו שורות הערך של a and b יוצא זהה לערך של a or b?
ובאלו שורות הוא שונה?

a	b	a or b
True	True	True
True	False	True
False	True	True
False	False	False

נסו בעצמכם

a=True
b=True
print(a or b)

a=2>1
b=2<1
print(a or b)


print(False or False)

שאלת חשיבה: אם נתון שa=True, ולא ידוע הערך של b, מה יהיה הערך של a or b?

האופרטור not

תחביר: not a. כלומר not מבוצע רק על ערך בוליאני יחיד!
מחזיר True אם a הוא False. אחרת, מחזיר True

a	not a
True	False
False	True

נסו בעצמכם

a=True
print(not a)

a=2<1
print(not a)

print(not False)

False
True
True

שירשור אופרטורים לוגיים

בדומה לפעולות אריתמתיות, ניתן לשרשר מספר אופרטורים לוגיים ברצף סדר פעולות:

1. not קודם לכולם

2. and קודם לor(כמו שכפל קודם לחיבור)

3. or מגיע בסוף.

נסו בעצמכם

print (True and True and False)

print ((2>1 or 1<2) and 1==1)
print ((2>1 or 1<2) and 1==1)
print ((2>1 or 1<2) and not 1==1)
print (not 2==2 or 1==1)

False
True
True
False
True

סיכום אופרטורים לוגיים

אופרטור	תיאור
x and y	שניהם נכונים: True, אחרת: False
x or y	לפחות אחד מהם נכון: True, אחרת: False
not x	אם x הוא False –> התוצאה היא True, אם x הוא True –> התוצאה היא False

From: 1_3_strings.ipynb

vendor/virtual-pyprog/1_3_strings.ipynb

טיפוס מחרוזת: str

אג’נדה

• הסבר על הטיפוס str

• פעולות בסיסיות על מחרוזות (+, *, in, len)

• גישה לחלקים מהמחרוזת באמצעות אינדקסים

• פעולות מתקדמות על מחרוזות (מתודות)

• מחרוזת - אובייקט בלתי ניתן לשינוי (immutable)

• ייצוג מחרוזזת במחשב

• פעולות השוואה

בחלק זה נלמד איך לייצג טקסט בפייתון. לשם כך נשתמש בערכים מסוג מחרוזת (string). בפייתון, שם הטיפוס הוא str.

לנוחיותכם חלונית עם הקוד שראינו בסרטון. מוזמנים להריץ בעצמכם.

# print(Hello world!)
# print(3)
# print("3")
# print(3 + "3")
s = "This is a string"
# print(s)
print("3+4 =", 3*4)

בחנו את בעצמכם

בתרגיל זה תדפיסו מחרוזת מורכבת שתדפיס את שמכם ואת גילכם.

תחילה, הגדירו שני משתנים:

• המשתנה הראשון ייקרא name וערכו יהיה מחרוזת עם השם שלכם.

• המשתנה השני ייקרא age וערכו יהיה הגיל שלכם בשנים.

לדוגמה: סטודנטית בת 23 בשם עדי תגדיר את המשתנים הבאים:

name =  "Adi"
age =  23

לאחר מכן, עליכם להדפיס מחרוזת מורכבת (תוך שימוש בפקודה print עם פסיקים, כפי שהודגם בסרטון) שתדפיס את השם ואת הגיל לפי הפורמט הבא:

"My name is <your name> and I am <your age> years old"

כאשר במקום יופיע השם שלכם כפי שהוגדר במשתנה name, ובמקום יופיע הגיל שלכם כפי שהוגדר במשתנה age. למשל, כאשר הסטודנטית עדי, אותה פגשנו זה עתה, תריץ את הקוד שלה, יודפס:

"My name is Adi and I am 23 years old"

רמז: כדי לייצר מחרוזות מורכבות יש להפריד בין חלקי המחרוזת בעזרת פסיקים.

### write your code here

אופרטורים על מחרוזות

לנוחיותכם חלונית עם הקוד שראינו בסרטון. מוזמנים להריץ בעצמכם.

# print("Hello " + "World")
# print("Hello" + " " + "World")
# print("Hello" * 3)
s1 = "Hello"
s2 = s1 * 3
# print(s2)
# print(("Hello" + "World") * 2)
# print(len("a b c d e"))
# print(len(""))
# print("H" in "Hello")
# print("ell" in "Hello")
# print("G" in "Hello")
print("bell" in "Hello")

False

בחנו את בעצמכם

מה מודפס בקטע הקוד הבא:

s="ab"
print(s*(len(s)+len("")))

פעולות נוספות של מחרוזות

לנוחותכם חלונית עם הקוד שראינו בסרטון. מוזמנים להריץ בעצמכם:

#print("ab" == "ab")
#print("ab" != "ab")
#print("ab" < "cd")
#print("abc" < "!@#")
s = "Python"
# print(s[0])
# print(s[1])
# print(s[2])
# print(s[3])
# print(s[4])
# print(s[5])
#print(s[6])
print(s[len(s) - 1])

n

סיכום: אופרטורים של מחרוזות

נניח כי ביצענו את ההשמות הבאות:

a = 'Hello'
b = 'Python'

אופרטור	תיאור	דוגמה
+	שרשור - מחבר ערכים משני צידי האופרטור	a + b יתן 'HelloPython'
*	חזרה - יוצר מחרוזות חדשות ע״י שרשור חוזר של אותה מחרוזת	a*2 יתן 'HelloHello'
in	בדיקת חברות - מחזיר אמת אם תת מחרוזת קיימת במחרוזת	'H' in a יתן True
not in	בדיקת אי-חברות - מחזיר אמת אם תת מחרוזת לא קיימת במחרוזת	'M' not in a יתן True
len	בדיקת מספר התווים במחרוזת/אורך המחרוזת	len("test") יתן 4

גישה לתווים במחרוזות

לאחר שקיבלנו את האינדקס, או אם אנחנו יודעים אותו מראש - ראינו בסרטון שניתן לגשת אל התו שנמצא באותו מקום במחרוזת באמצעות סוגריים מרובעים: []. תזכורת חשובה - אינדקסים בפייתון מתחילים ב־0, כלומר התו הראשון במחרוזת נמצא באינדקס 0, השני באינדקס 1, וכן הלאה.
ניתן גם לספור תווים מהסוף - התו האחרון במחרוזת נמצא גם באינדקס 1-, התו לפני האחרון נמצא באינדקס 2- וכן הלאה.

דוגמה: המחרוזת “Hello” והאינדקסים התואמים כל אות.

a='Hello'
print(a[0])
print(a[1])
print(a[-1])
print(a[4])

H
e
o
o

גם באינדקסים שליליים - ומה יקרה אם ננסה לגשת לאינדקס שלא קיים במחרוזת?

print(a[-6])

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[37], line 1
----> 1 print(a[-6])

IndexError: string index out of range

Slicing של מחרוזת

בפייתון ניתן לגשת לא רק לתו אחד במחרוזת, אלא גם לחתיכה (slice) שלמה ממנה.
התחביר הוא: string[start:end:step]

• האינדקס הראשון (start) כלול בחיתוך.

• האינדקס האחרון (end) לא כלול - החיתוך נעצר לפניו.

• גודל הצעד הבא (step). בברירת המחדל הגודל הוא 1. לדוגמא:

text="hello world"
print(text[0:7])

hello w

בדוגמא לעיל הדפסנו את שבעת התווים הראשונים - מ-0 (כולל) עד 7 (לא כולל).

שימו לב שרווח נחשב גם הוא כתו

דוגמא נוספת:

print(text[0:7:3])

hlw

גם בדוגמא זו הדפסנו תווים משבעת האינדקסים הראשונים, אך בפעם ביצענו קפיצות של 3 בין כל זוג תווים (במקום קפיצה של 1). כלומר, הדפסנו את התווים המופיעים באינדקסים 0, 3 ו-6

בואו נתרגל זאת על המחרוזת האהובה עלינו:

a = 'Hello'

print(a[1])
print(a[1:3])

e
el

ערך step שלילי

אם הערך של step הוא שלילי, אזי הכיוון שבו נעבור לאינדקס הבא יהיה מהסוף להתחלה, כלומר נרוץ “אחורה” על המחרוזת.
במקרה זה אם האינדקס start יהיה גדול או שווה מהאינדקס end תתקבל רשימה ריקה.

בדוגמא להלן, מתחילים לרוץ מהאינדקס 4 לאחור עד לאינדקס 1:

a[4:1:-1]

'oll'

ערכי ברירת מחדל לאינדקסים start וend

אם נשאיר את start ריק, אזי start ייבחר אוטומטית להיות 0 - תחילת המחרוזת.

אם נשאיר את end ריק, אזי end ייבחר אוטומטית להיות len(string) - כך שהחיתוך יגיע לסוף המחרוזת.

print(a[:5])
print(a[1:])

Hello
ello

לעומת זאת, אם הערך של jump הוא שלילי, אזי ערכים ברירת המחדל של האינדקסים start ו-end יהיו הפוכים: start יהיה סוף המחרוזת, והאינדקס end יהיה תחילת המחרוזת

a[::-1]

'olleH'

ערכים שליליים לאינקסים

כפי שלמדנו, ניתן להשתמש גם באינדקסים השליליים לציון התווים במחרוזת.

print(a[-4:-2])
print(a[:-3])
print(a[-3:])

תרגול: פלינדרום

את השפה העברית אנחנו כותבים וקוראים בד”כ מימין לשמאל. כך גם בערבית. לעומת זאת בשפות כמו אנגלית, רוסית, צרפתית וגם באמהרית כותבים וקוראים משמאל לימין. בכל השפות האלו ובאחרות ישנן מילים שאפשר לקרוא אותן בשני הכיוונים באותו אופן. למשל, המילה ‘אמא’ בעברית, או המילה radar באנגלית. מילים כאלו נקראות “פלינדרום”.

כעת ננסח בצורה מעט יותר פורמלית את בעית הפלינדרום. הקלט לבעיה שלנו הוא מחרוזת. אם המחרוזת ניתנת לקריאה בשני הכיוונים באופן זהה הפלט יהיה True.

דוגמא למחרוזת שהן פלינדרום:

• 21.11.12

• alula

• anna

• deified

כעת השלימו את הפונקציה הבאה, המחזירה True אם המחרוזת text בקלט היא פלינדרום, וFalse אחרת.

def is_palindrome(text):
    # Your code here

print(is_palindrome('abba'))
print(is_palindrome('abbc'))

  Cell In[31], line 4
    print(is_palindrome('abba'))
    ^
IndentationError: expected an indented block after function definition on line 1

לחצו כאן כדי לצפות בפתרון

def is_palindrome(text):
    return text == text[::-1]```

כדאי לדעת!

זיהוי פלינדרום היא בעיה קלאסית במדעי המחשב. בהמשך הקורס, נפגוש בה שוב, ונעמיק בגישות שונות לפתרונה.

פונקציות ומתודות של מחרוזות

כפי שראינו, הטיפוס str בפייתון מייצג טקסט.
ישנן מגוון פעולות שונות שנרצה לבצע על טקסט, מימוש של כל פעולה כזו נקרא פונקציה.

כבר נתקלתם בפונקציה אחת: len - המחזירה את אורך של אובייקט. במקרה שלנו, הפעלנו את הפונקציה על אובייקט מסוג מחרוזת, וכך קיבלתנו את מספר התווים במחרוזת.

בניגוד לפונקציה len, ישנן פונקציות נוספות שהן ייחודיות - או משויכות - לטיפוס מסוים פונקציות אלו נקראות גם מתודות.

למתודות של תחביר הפעלה מעט שונה משל פונקציות רגילות. כאן אנו כותבים קודם את שם המשתנה (או באובייקט) עליו רוצים לבצע את הפעולה, ולאחר מכן את שם פעולה (או המתודה), כאשר מפרידים ביניהם באמצעות נקודה:

variable_name.method_name(...)

לדוגמא, נניח נרצה שנרצה לחפש היכן מופיע תו כלשהו במחרוזת. לצורך כך נשתמש בפעולה find, שמחזירה את האינדקס (=המיקום) של ההופעה הראשונה של התו/המחרוזת שחיפשנו. אם החיפוש לא מצליח – הפונקציה מחזירה -1.
על מנת להפעיל את המתודה find על המשתנה a כדי לחפש את המופע הראשון של H, נכתוב את השורה a.find('H'):

a = 'Hello'
print(a.find('H'))

בדומה לfind, קיימות מתודות נוספות.

ערכו את הקוד להלן, ונסו להבין בעצמכם מה עושות המתודות הבאות:

txt="my name is Assaf"
print(txt.upper())
print(txt.lower())
print(txt.replace("sa", "i"))
print(txt.title())

MY NAME IS ASSAF
my name is assaf
my name is Asif
My Name Is Assaf

כפי שניתן לראות, קיימות פעולות רבות ושימושיות לעבודה עם מחרוזות.
אנחנו ממליצים לכם כבר עכשיו להתחיל להכין מסמך אישי שבו תרכזו את כל הפעולות שלמדתם. המסמך הזה ילווה אתכם לאורך הקורס, יעזור בשיעורי הבית, בהכנה למבחן, ואפילו יהפוך לכלי שימושי בהמשך דרככם כמתכנתים.

להלן רשימת פעולות שימושיות במיוחד שכדאי להכניס למסמך. חפשו עליהן מידע בגוגל או בעזרת מודל AI כדי להבין מה הן עושות ואיך משתמשים בהן:

• len

• find, startswith, endswith

• isalpha, isdigit, islower

• join, replace

• strip, rstrip

• split

חשוב מאוד להכיר את פעולות אלו – הן יאפשרו לכם לפתור בעיות רבות!

שימו לב שמתודות של מחרוזות אינן משנות את המחרוזת המקורית ממנה הן הופעלו

• למעשה, לא ניתן לשנות את המחרוזת המקורית מכיוון שהיא אובייקט שאינה ניתנת לשינוי. נרחיב על עקרון זה בהמשך המחברת.

:חשבו

איך בכל זאת אפשר לשנות את ערכו של משתנה מטיפוס מחרוזת ממנו הופעלה מתודה מסוימת?

למידע נוסף: Python Strings – TutorialsPoint מומלץ גם לחפש בגוגל שיטות נוספות של str כדי להרחיב את ארגז הכלים שלכם.

מחרוזות הן אובייקטים בלתי ניתנים לשינוי (immutable objects)

למדנו שניתן להסתכל על תו מסוים במחרוזת על ידי גישה לאינדקס - a[0].

למדנו גם שניתן לבצע השמה - לקחת ערך מסוים, ולהכניס אותו למשתנה.

אז מה יקרה אם נרצה לערוך מחרוזת? לדוגמה - להחליף את התו הראשון במחרוזת באות אחרת?

a = "Hello"
a[0] = "J"

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[39], line 2
      1 a = "Hello"
----> 2 a[0] = "J"

TypeError: 'str' object does not support item assignment

מחרוזות הן טיפוס immutable - כלומר לא ניתנים לשינוי אחרי יצירתם. זה אומר שלא ניתן לערוך מחרוזת קיימת.

הדרך היחידה “לשנות” מחרוזת בתוך משתנה קיים, היא ליצור מחרוזת חדשה עם השינוי שרצינו ולבצע השמה מחדש (=).

s = "J" + a[1:]
print(s)

לדוגמא לעיל ביצענו למעשה מספר פעולות בשורה אחת:

1. a[1:] - יצירת מחרוזת חדשה המכיל את כל התווים של המחרוזת במשתנה a מלבד התו הראשון

   • שימו לב כי המחרוזת בa איננה משתנה!

2. חיבור האות “J” עם המחרוזת שנוצרה ב(1)

3. השמה של תוצאת החיבור מ(2) בתוך s

ניתן לשמור את המחרוזת החדשה במשתנה בעל אותו שם, ובכך לדרוס את הערך הקודם, וכך המחרוזת חדשה תשמר במשתנה בעל השם הרצוי.

a="Hello"
print(a)
a="J" + a[1:] 
print(a)

Hello
Jello

כפי שציינו קודם, גם מתודות לא משנות את האובייקט מקורי מהן הופעלו.
לדוגמא:

לדוגמא, הפעולה a.upper() מחזירה את המחרוזת באותיות גדולות:

a="Hello"
print(a.upper())

HELLO

אך המתודה איננה מעדכנת את ערך במשתנה a

a.upper()
print(a)

Hello

לכן, בדומה למקרה הקודם, אם ברצוננו לעדכן את a, נשתמש בהשמה על מנת לעדכן את a בערך החדש - a.upper()

a=a.upper()
print(a)

HELLO

מסקנה: כל פעולה על מחרוזות מחזירה משתנה חדש במקום לשנות את המקורי.

a = "hello"
b = a.title()
print("a value is:", a)
print("b value is:", b)

ייצוג מחרוזות במחשב

תווי בקרה

בפייתון קיימים תווי בקרה (escape characters) שנכתבים עם \ ומשמשים לייצוג תווים מיוחדים. למשל, שני תווים נפוצים הם:

• n\ מייצג ירידת שורה

• t\ מייצג טאב

טבלת ASCII

עד עכשיו למדנו איך לעבוד עם מחרוזות בתוך פייתון, אבל כדי להבין מה באמת קורה “מאחורי הקלעים” חשוב לדעת גם איך המחשב שומר וקורא מחרוזות בזיכרון. לכל תו במחרוזת יש מספר - לפי טבלת ASCII (ראשי תיבות של American Standard Code for Information Interchange).

טבלת ASCII מקשרת (או מקודדת) בין תווים למספרים, כך שמחשב יוכל להבין טקסט. לכל תו — כמו אות, ספרה או סימן — יש ערך מספרי קבוע (למשל ‘A’ = 65, ‘0’ = 48). כך מחשבים שונים יכולים לייצג ולהעביר טקסט בצורה אחידה.

להלן טבלת הASCII - בה מופיעים כל התווים (עמודת char) והייצוג המספרי שלהם (עמודת Dec).

כדי להמיר מתו למספר ולהיפך, ניתן להשתמש בפונקציות chr וord:

print(chr(77))
print(ord("M"))

M
77

אופרטורי השוואה בין מחרוזות

אחרי שלמדנו קידוד תווים באמצעות טבלת ASCII נרחיב על השוואה בין מחרוזות.

כפי שלמדנו מוקדם יותר ביחידה זו, ניתן להשתמש באופרטורי ההשוואה גם עבור מחרוזות. כאשר משווים בין מחרוזות בפייתון, ההשוואה מתבצעת בצורה לקסיקוגרפית לפי ערכי ה־ASCII של התווים. המשמעות היא שהמחשב בודק כל תו במחרוזת לפי סדר הופעתו, ומשווה את הערך המספרי שלו בטבלת ASCII לתו המקביל במחרוזת השנייה. אם התווים הראשונים שווים, ההשוואה ממשיכה לתווים הבאים, עד שנמצא הבדל או עד שאחת המחרוזות מסתיימת.

שימו לב שהתווים האלפבתים באים ברצף: אותיות גדולות נמצאות בטווח 65-90 ואותיות קטנות נמצאות בטווח 97-122, כך שיחס הסדר בין מחרוזות שבכולן אותיות גדולות בלבד או קטנות בלבד דומה ליחס הסדר במילון אנגלי. למשל, “apple” < “banana” יחזיר True כי האות ‘a’ מופיעה לפני ‘b’ בטבלת ASCII.

לעומת זאת, “Zoo” < “apple” יחזיר גם הוא True, משום שהאות ‘Z’ גדולה באותיות גדולות אבל הערך שלה ב־ASCII נמוך יותר מהערך של ‘a’.

לכן חשוב לשים לב שבעת השוואת מחרוזות, האותיות קטנות וגדולות נחשבות שונות, והסדר מושפע ישירות מהקוד המספרי של כל תו ולא מההיגיון הלשוני שלנו.

דוגמא נוספת: “[” > “HELLO” מכיוון בערך הASCII של התו “[” גדול מזה של התו H

print('apple'<'banana')
print('Zoo'<'apple')
print('HELLO'>'[')
print('python'=='Python') # Why?

True
True
False
False

בחנו את עצמכם:

באופן דומה לחיפוש במילון: אם התו הראשון זהה, אז נבצע את ההשוואה לפי התו השני.

לבסוף, אם הגענו לסוף המחרוזת בלי שמצאנו תו שונה, אז המחרוזת הקצרה יותר היא הקטנה.

From: 1_4_conversion.ipynb

vendor/virtual-pyprog/1_4_conversion.ipynb

המרות בין טיפוסים

נניח שאנחנו רוצים לבדוק כמה ספרות יש במספר כלשהו. לדוגמא - ב10 יש שתי ספרות, וב256 יש שלוש ספרות. אם נחשוב על המספר כ־int, זה לא ממש פשוט. לא ניתן לבצע len על ערך מסוג int. למעשה, כרגע אין בידינו את הכלים לבדוק זאת (אך בהמשך הקורס נלמד אותם ואף נחזור לשאלה הזו).

מצד שני, אם היינו יכולים לקבל את המספר 10 כמחרוזת “10”, אז יש לנו את הפקודה len וזה נהיה פשוט מאוד!

אפשר לבצע המרה באמצעות שם הטיפוס עצמו, כפונקציה:

num = 12345
print(type(num))

num = str(num)
print(type(num))

<class 'int'>
<class 'str'>
5

וכך נוכל לספור את כמות הספרות:

num = 12345
print(len(str(num)))

5

אילו טיפוסים ניתן להמיר?

באופן עקרוני, ניתן לנסות לבצע המרה מכל טיפוס לכל טיפוס. ההמרה תתבצע בהצלחה רק אם הערך שאותו מנסים למהיר “הגיוני” עבור טיפוס אליו מנסים להמיר. לדוגמה:

• את המחרוזת “12” נוכל להמיר לטיפוסים int וfloat

• את המחרוזת “10.5” נוכל להמיר בהצלחה לfloat בלבד

• את המחרוזת “hello world” לא ניתן להמיר בהצלחה באף אחד מהטיפוסים המספריים.

בהמשך נלמד עוד סוגים - וכמובן שניתן לנסות לבצע המרה גם לטיפוסים הללו.

התנסו בעצמכם

num = 123
print(num, type(num))
num_str = str(num)
print(num, type(num))
num_float = float(num)
print(num_float, type(num_float))

מה יקרה אם ניסיון המרה נכשל? מה יקרה אם ננסה להמיר לטיפוס לא מתאים?

# Your code here

האם ניתן להמיר float לא שלם לint? בדקו זאת!

אילו טיפוסים ניתן להמיר לבוליאני? לאילו טיפוסים ניתן להמיר ערך בוליאני?

print(int(True))
print(bool(0))

# Try converting more values and see what happens!

1
False